Inheritance and Substitution גרא וייס המחלקה למדעי המחשב אוניברסיטת בן-גוריון

Transcription

1 Inheritance and Substitution גרא וייס המחלקה למדעי המחשב אוניברסיטת בן-גוריון

2 2 Roadmap In this chapter we will start to investigate the concepts of inheritance and substitution: The intuitive and practical meanings of inheritance The syntax used to describe inheritance and substitution Some of the various forms of inheritance The benefits and costs of inheritance

3 3 Abstract idea of Inheritance We motivated the idea of inheritance with a hierarchy of categories: Material Object Living Thing Non-Living Thing Reptile Mammal Rock Human Being Cat Dog Platypus Air Dentist Artist Shopkeeper Ken Beth Celia

4 4 Practical Meaning of Inheritance Data members in the parent are part of the child Behavior defined in the parent are part of the child Note that private aspects of the parent are part of the child, but are not always accessible within the child class

5 5 Private, Public and Protected There are now three levels of visibility modifiers: Private: accessible only within the class definition (but memory is still found in the child class, just not accessible) Public: accessible anywhere Protected: accessible within the class definition or within the definition of child classes Note: Java interprets protected to mean accessible also within the same package

6 6 Controlling Access to Members of a Class in Java The following table shows the access to members permitted by each modifier: Modifier Class Package Subclass World public Y Y Y Y protected Y Y Y N no modifier Y Y N N private Y N N N

7 7 Inheritance is Both Extension and Contraction Because the behavior of a child class is strictly larger than the behavior of the parent, the child is an extension of the parent (larger) Because the child can override behavior to make it fit a specialized situation, the child is a contraction of the parent (smaller) This interplay between inheritance and overriding, extension and contraction, is what allows objectoriented systems to take very general tools and specialize them for specific projects

8 8 The is-a Rule Our idealization of inheritance is captured in a simple rule-of-thumb: Try forming the English sentences An A is-a B. If it sounds right to your ear, then A can be made a subclass of B A dog is-a mammal, and therefore a dog inherits from mammal A car is-an engine sounds wrong, and therefore inheritance is not natural But a car has-an engine

9 9 Examples A Bird is an Animal A Cat is a Mammal An Apple Pie is a Pie A TextWindow is a Window A Ball is a GraphicalObject An IntegerArray is an Array A Bird is a Mammal An Apple Pie is an Apple An Engine is a Car A Ball is a Wall An IntegerArray is an Integer

10 10 Reuse of Code, Reuse of Concept Why do we use inheritance? Basically there are two major motivations: Reuse of code. Methods defined in the parent can be made available to the child without rewriting. Makes it easy to create new abstractions. Reuse of concept. Methods described in the parent can be redefined and overridden in the child. Although no code is shared between parent and child, the concept embodied in the definition is shared. An example of the latter: All graphical objects know how to draw

11 11 Syntax for Inheritance Languages use a variety of different syntax to indicate inheritance: class Wall : public GraphicalObject -- C++ class Wall extends GraphicalObject -- Java class Wall : GraphicalObject -- C# (defclass Wall (GraphicalObject) () ) -- CLOS type Wall = object (GraphicalObject) -- Object Pascal class Wall < GraphicalObject -- Ruby

12 12 Trees vs. Forests There are two common views of class hierarchies: All classes are part of a single large class hierarchy. Thus, there is one class that is the original ancestor of all other classes. Smalltalk, Java and Delphi Pascal do this. Classes are only placed in hierarchies if they have a relationship - results in a forest of many small hierarchies, but no single ancestor. C++, Objective-C, and Apple Object Pascal do this.

13 13 A portion of the Little Smalltalk Hierarchy

14 14 An Argument for Substitution Consider the following argument: Instances of the subclass must possess all data areas associated with the parent class Instances of the subclass must implement, through inheritance at least (if not explicitly overridden) all functionality defined for the parent class Thus, an instance of a child class can mimic the behavior of the parent class It therefore seems reasonable that a variable declared as a parent, should be able to hold a value generated from the child class

15 15 Subclass vs. Subtype Of course, the problem with this argument is that a child class can override a method and make arbitrary changes It is therefore useful to define two separate concepts: To say that A is a subclass of B merely asserts that A is formed using inheritance To say that A is a subtype of B asserts that A preserves the meaning of all the operations in B It is possible to form subclasses that are not subtypes; and (in some languages at least) form subtypes that are not subclasses

16 16 Substitution and Strong Typing Statically typed languages place much more emphasis on the principle of substitution than do dynamically typed languages The reason for this is that statically typed languages tend to characterize objects by their class, whereas dynamically typed languages tend to characterize objects by their behavior For example, a polymorphic function in a statically typed language can ensure a certain level of functionality only by insisting that all arguments be subclasses of a given class Since in a dynamically typed language arguments are not typed at all, the same requirement would be simply that an argument must be able to respond to a certain set of messages

17 17 Syntax for Overriding Some languages, such as C++, require that the programmer indicate in the parent class that overriding is a potential: class GraphicalObject { public: virtual void draw(); // can be overridden }; Other languages, such as Object Pascal, require a modifier in the child class that overriding has taken place: type end Ball = object (GraphicalObject)... procedure draw; override; (* overriding has taken place *) Still other languages (C#, Delphi) require indications in both parent and child. And some languages (Smalltalk) do not require any indication in either parent class or child class

18 18 Interfaces and Abstract Classes An interface is similar to a class, but does not provide any implementation. A child class must override all methods. A middle ground is an abstract class. Here some methods are defined, and some (abstract methods) are undefined. A child class must fill in the definition for abstract methods: abstract class Window {... abstract public void paint (); // child class must redefine... } An interface is like an abstract class in which all methods are abstract

19 19 Pure Virtual In C++ the idea of an abstract method is termed a pure virtual method, and is indicated using the assignment operator: class Window { public:... virtual void paint () = 0; // assignment makes it pure virtual... } A class can have both abstract (or pure virtual) methods and non-abstract methods A class in which all methods were declared as abstract (or pure virtual) would correspond to the Java idea of an interface

20 20 Simulating Abstract Methods Abstract methods can be simulated even when the language does not provide explicit support for the concept In Smalltalk, for example, programmers frequently define a method so as to generate an error if it is invoked, with the expectation that it will be overwritten in child classes: writeto: stream self error: subclass must override writeto This is not exactly the same as a true abstract method, since it does not preclude the creation of instances of the class Nevertheless, if an instance is created and this method invoked the program will quickly fail, and hence such errors are easily detected

21 21 Forms of Inheritance The choices between inheritance and overriding, subclass and subtypes, mean that inheritance can be used in a variety of different ways and for different purposes Many of these types of inheritance are given their own special names. We will describe some of these specialized forms of inheritance: Generalization or Extension Specialization Specification Construction Limitation Variance

22 22 Specialization Inheritance By far the most common form of inheritance is for specialization A good example is the Java hierarchy of Graphical components: Component Label Button TextComponent TextArea TextField CheckBox ScrollBar Each child class overrides a method inherited from the parent in order to specialize the class in some way

23 23 Specification Inheritance If the parent class is abstract, we often say that it is providing a specification for the child class, and therefore it is specification inheritance Example: Java Event Listeners: ActionListener, MouseListener, and so on specify behavior, but must be subclasses A class that implements an interface is always fulfilling this form of inheritance However, subclassing for specification can also arise in other ways

24 24 Example Public interface ActionListener { public void actionperformed(actionevent e) {}; } public class Beeper... implements ActionListener { //where initialization occurs:... button.addactionlistener(this);... } public void actionperformed(actionevent e) { Toolkit.getDefaultToolkit().beep(); }

25 25 Inheritance for Construction If the parent class is used as a source for behavior, but the child class has no is-a relationship to the parent, Then we say the child class is using inheritance for construction An example might be subclassing the idea of a Set from an existing List class Generally not a good idea, since it can break the principle of substitutability, But nevertheless sometimes found in practice More often in dynamically typed languages, such as Smalltalk

26 26 Example public class List... { } public class Set extends List { public void clear() { } } public boolean isempty() { } public void add(e e) { } public E remove(e e) { }

27 27 Inheritance for Generalization or Extension When a subclass extends the behavior of the parent class to create a more general kind of object Consider a graphics display system in which a class Window has been defined for displaying on a simple black-and-white background You could create a subtype ColoredWindow that lets the background color be something other than white by adding an additional field to store the color and overriding the inherited window display code that specifies the background be drawn in that color Subclassing for generalization is often applicable when we build on a base of existing classes that we do not wish to modify, or cannot modify As a rule, subclassing for generalization should be avoided in favor of inverting the type hierarchy and using subclassing for specialization

28 28 Example public class Hashtable { public int size() { } public boolean isempty() { } public Enumeration keys() { } } public Enumeration elements() { } public class Properties... extends Hashtable { public Object setproperty(string key, String value) {} public void load(inputstream instream) throws IOException {} } public void save(outputstream out, String header) {}

29 29 Inheritance for Limitation If a child class overrides a method inherited from the parent in a way that makes it unusable (for example, issues an error message), then we call it inheritance for limitation. For example, you have an existing Dequeue data type that allows items to be inserted at either end, And you override methods allowing insertion at one end in order to create a Stack Generally not a good idea, since it breaks the idea of substitution But again, it is sometimes found in practice

30 30 Example public class List { public void insert (E element, Position p) { if ((!this.isempty()) && (p == front)) //insert the element in the front } } if ((!this.isempty()) && (p == end)) //insert the element in the end public class Stack extends List { public void insert (E element) { if (!this.isempty()) //insert the element in the top } }

31 31 Inheritance for Variance Two or more classes that seem to be related, but its not clear who should be the parent and who should be the child Example: Mouse and TouchPad and Joystick One of the classes is then arbitrarily selected to be the parent, with the common code being inherited by the others and device-specific code being overridden Better solution: abstract out common parts to new parent class, and use subclassing for specialization

32 32 Summary of Forms of Inheritance Specialization. The child class is a special case of the parent class; in other words, the child class is a subtype of the parent class. Specification. The parent class defines behavior that is implemented in the child class but not in the parent class. Construction. The child class makes use of the behavior provided by the parent class, but is not a subtype of the parent class. Generalization. The child class modifies or overrides some of the methods of the parent class. Extension. The child class adds new functionality to the parent class, but does not change any inherited behavior. Limitation. The child class restricts the use of some of the behavior inherited from the parent class. Variance. The child class and parent class are variants of each other, and the class-subclass relationship is arbitrary. Combination. The child class inherits features from more than one parent class. This is multiple inheritance and will be the subject of a later chapter.

33 33 Benefits of Inheritance Software Reuse Code Sharing Consistency of Interface Software Components Rapid Prototyping Polymorphism Information Hiding

34 34 Cost of Inheritance Program size Execution speed Program Complexity Message Passing Overhead This does not mean you should not use inheritance, But rather than you must understand the benefits, and weigh the benefits against the costs

35 35 Chapter Summary In this chapter we have begun the exploration of inheritance, A topic we will continue through the next several chapters Topics we have addressed have included the following: The meaning of inheritance The syntax used to describe inheritance and overriding The idea of substitution of a child class for a parent The various forms of inheritance The cost and benefits of inheritance